home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / CLOBSH.PAK / ARRAY.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  19KB  |  799 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  ARRAY.H                                                               */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991, 1993                            */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __ARRAY_H )
  11. #define __ARRAY_H
  12.  
  13. #define BI_OLDNAMES
  14.  
  15. #if !defined( TEMPLATES )
  16.  
  17. #if !defined( __CLSTYPES_H )
  18. #include "classlib\obsolete\ClsTypes.h"
  19. #endif  // __CLSTYPES_H
  20.  
  21. #if !defined( __OBJECT_H )
  22. #include "classlib\obsolete\Object.h"
  23. #endif  // __OBJECT_H
  24.  
  25. #if !defined( __ABSTARRY_H )
  26. #include "classlib\obsolete\AbstArry.h"
  27. #endif  // __ABSTARRY_H
  28.  
  29. #pragma option -Vo-
  30. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  31. #pragma option -po-
  32. #endif
  33.  
  34. _CLASSDEF(Array)
  35.  
  36. class _CLASSTYPE Array : public AbstractArray
  37.  
  38. {
  39.  
  40. public:
  41.  
  42.     Array( int upper, int lower = 0, sizeType aDelta = 0 ) :
  43.         AbstractArray( upper, lower, aDelta )
  44.         {
  45.         }
  46.  
  47.     virtual void add( Object _FAR & );
  48.     void addAt( Object _FAR &, int );
  49.  
  50.     virtual classType isA() const
  51.         {
  52.         return arrayClass;
  53.         }
  54.  
  55.     virtual _TCHAR _FAR *nameOf() const
  56.         {
  57.         return "Array";
  58.         }
  59.  
  60. };
  61.  
  62. #else   // TEMPLATES
  63.  
  64. #if !defined( __ARRAYS_H )
  65. #include "classlib\Arrays.h"
  66. #endif  // __ARRAYS_H
  67.  
  68. #pragma option -Vo-
  69. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  70. #pragma option -po-
  71. #endif
  72.  
  73. #define Array   BI_TCArrayAsVector
  74. #define PArray  PBI_TCArrayAsVector
  75. #define RArray  RBI_TCArrayAsVector
  76. #define RPArray RPBI_TCArrayAsVector
  77. #define PCArray PCBI_TCArrayAsVector
  78. #define RCArray RCBI_TCArrayAsVector
  79.  
  80. _CLASSDEF( BI_TCArrayAsVector )
  81.  
  82. #define ArrayIterator   BI_TCArrayAsVectorIterator
  83. #define PArrayIterator  PBI_TCArrayAsVectorIterator
  84. #define RArrayIterator  RBI_TCArrayAsVectorIterator
  85. #define RPArrayIterator RPBI_TCArrayAsVectorIterator
  86. #define PCArrayIterator PCBI_TCArrayAsVectorIterator
  87. #define RCArrayIterator RCBI_TCArrayAsVectorIterator
  88.  
  89. _CLASSDEF( BI_TCArrayAsVectorIterator )
  90.  
  91. #if !defined( __RESOURCE_H )
  92. #include "classlib\Resource.h"
  93. #endif  // __RESOURCE_H
  94.  
  95. #if !defined( __COLLECT_H )
  96. #include "classlib\obsolete\Collect.h"
  97. #endif  // __COLLECT_H
  98.  
  99. #if !defined( __SORTABLE_H )
  100. #include "classlib\obsolete\Sortable.h"
  101. #endif  // __SORTABLE_H
  102.  
  103. #if !defined( __ABSTARRY_H )
  104. #include "classlib\obsolete\AbstArry.h"
  105. #endif  // __ABSTARRY_H
  106.  
  107. /*------------------------------------------------------------------------*/
  108. /*                                                                        */
  109. /*  class BI_OArrayAsVector                                               */
  110. /*                                                                        */
  111. /*  Implements an array of pointers to Object,                            */
  112. /*  using a vector as the underlying implementation.                      */
  113. /*                                                                        */
  114. /*------------------------------------------------------------------------*/
  115.  
  116. class _CLASSTYPE BI_OArrayAsVector
  117. {
  118.  
  119. public:
  120.  
  121.     friend class _CLASSTYPE BI_OArrayAsVectorIterator;
  122.  
  123.     BI_OArrayAsVector() : oarray( DEFAULT_ARRAY_SIZE )
  124.         {
  125.         }
  126.  
  127.     BI_OArrayAsVector( int upr, int lwr = 0, unsigned delta = 0 ) :
  128.         oarray( upr, lwr, delta )
  129.         {
  130.         }
  131.  
  132.     Object *operator [] (int loc)
  133.         {
  134.         return oarray[loc];
  135.         }
  136.  
  137.     Object *operator [] (int loc) const
  138.         {
  139.         return oarray[loc];
  140.         }
  141.  
  142.     int lowerBound() const
  143.         {
  144.         return oarray.lowerBound();
  145.         }
  146.  
  147.     int upperBound() const
  148.         {
  149.         return oarray.upperBound();
  150.         }
  151.  
  152.     sizeType arraySize() const
  153.         {
  154.         return oarray.arraySize();
  155.         }
  156.  
  157.     void add( Object _FAR *o )
  158.         {
  159.         oarray.add(o);
  160.         }
  161.  
  162.     void addAt( Object _FAR *o, int loc )
  163.         {
  164.         oarray.addAt(o,loc);
  165.         }
  166.  
  167.     void detach( int loc,
  168.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  169.                )
  170.         {
  171.         oarray.detach( loc, dt );
  172.         }
  173.  
  174.     void detach( Object _FAR *o,
  175.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  176.                )
  177.         {
  178.         oarray.detach( o, dt );
  179.         }
  180.  
  181.     void destroy( int i )
  182.         {
  183.         oarray.destroy( i );
  184.         }
  185.  
  186.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  187.         {
  188.         oarray.flush( dt );
  189.         }
  190.  
  191.     int hasMember( Object _FAR *o ) const
  192.         {
  193.         return oarray.hasMember(o);
  194.         }
  195.  
  196.     Object _FAR *findMember( Object _FAR *o ) const
  197.         {
  198.         int loc = oarray.find(o);
  199.         return loc != INT_MAX ? oarray[loc] : 0;
  200.         }
  201.  
  202.     int isEmpty() const
  203.         {
  204.         return oarray.isEmpty();
  205.         }
  206.  
  207.     int isFull() const
  208.         {
  209.         return oarray.isFull();
  210.         }
  211.  
  212.     void forEach( iterFuncType f, void _FAR *args )
  213.         {
  214.         oarray.forEach( f, args );
  215.         }
  216.  
  217.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  218.         {
  219.         return oarray.firstThat( f, args );
  220.         }
  221.  
  222.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  223.         {
  224.         return oarray.lastThat( f, args );
  225.         }
  226.  
  227.     int getItemsInContainer() const
  228.         {
  229.         return oarray.getItemsInContainer();
  230.         }
  231.  
  232.     int ownsElements()
  233.         {
  234.         return oarray.ownsElements();
  235.         }
  236.  
  237.     void ownsElements( int del )
  238.         {
  239.         oarray.ownsElements( del );
  240.         }
  241.  
  242. protected:
  243.  
  244.     BI_IArrayAsVector<Object> oarray;
  245.  
  246. };
  247.  
  248. class _CLASSTYPE BI_OArrayAsVectorIterator :
  249.     public BI_IArrayAsVectorIterator<Object>
  250. {
  251.  
  252. public:
  253.  
  254.     BI_OArrayAsVectorIterator( const BI_OArrayAsVector _FAR &a ) :
  255.         BI_IArrayAsVectorIterator<Object>(a.oarray)
  256.         {
  257.         restart();
  258.         }
  259.  
  260.     void restart()
  261.         {
  262.         BI_IArrayAsVectorIterator<Object>::restart();
  263.         if( current() == 0 )
  264.             (*this)++;
  265.         }
  266.  
  267. };
  268.  
  269. /*------------------------------------------------------------------------*/
  270. /*                                                                        */
  271. /*  class BI_TCArrayAsVector                                              */
  272. /*                                                                        */
  273. /*  Implements an Object array, with the full semantics of                */
  274. /*  the BC 2.0 style array, using a vector as the underlying              */
  275. /*  implementation.                                                       */
  276. /*                                                                        */
  277. /*------------------------------------------------------------------------*/
  278.  
  279. class _CLASSTYPE BI_TCArrayAsVector : public AbstractArray
  280. {
  281.  
  282. public:
  283.  
  284.     friend class _CLASSTYPE BI_TCArrayAsVectorIterator;
  285.  
  286.     BI_TCArrayAsVector( int upper, int lower = 0, sizeType delta = 0 ) :
  287.         array( upper, lower, delta )
  288.         {
  289.         }
  290.  
  291.     virtual Object& operator []( int loc )
  292.         {
  293.         return ptrToRef(array[loc]);
  294.         }
  295.  
  296.     virtual Object& operator []( int loc ) const
  297.         {
  298.         return ptrToRef(array[loc]);
  299.         }
  300.  
  301.     virtual int lowerBound() const
  302.         {
  303.         return array.lowerBound();
  304.         }
  305.  
  306.     virtual int upperBound() const
  307.         {
  308.         return array.upperBound();
  309.         }
  310.  
  311.     virtual sizeType arraySize() const
  312.         {
  313.         return array.arraySize();
  314.         }
  315.  
  316.     void add( Object _FAR &o )
  317.         {
  318.         array.add(&o);
  319.         }
  320.  
  321.     void addAt( Object _FAR &o, int loc )
  322.         {
  323.         array.addAt(&o,loc);
  324.         }
  325.  
  326.     virtual void detach( int loc, DeleteType dt = NoDelete )
  327.         {
  328.         array.detach( loc, dt );
  329.         }
  330.  
  331.     void detach( Object _FAR &o,
  332.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  333.                )
  334.         {
  335.         array.detach( &o, dt );
  336.         }
  337.  
  338.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  339.         {
  340.         array.flush( dt );
  341.         }
  342.  
  343.     int hasMember( Object _FAR &o ) const
  344.         {
  345.         return array.hasMember(&o);
  346.         }
  347.  
  348.     Object _FAR &findMember( Object _FAR &o ) const
  349.         {
  350.         return ptrToRef(array.findMember(&o));
  351.         }
  352.  
  353.     int isEmpty() const
  354.         {
  355.         return array.isEmpty();
  356.         }
  357.  
  358.     int isFull() const
  359.         {
  360.         return array.isFull();
  361.         }
  362.  
  363.     void forEach( iterFuncType f, void _FAR*args )
  364.         {
  365.         array.forEach( f, args );
  366.         }
  367.  
  368.     Object _FAR &firstThat( condFuncType f, void _FAR *args ) const
  369.         {
  370.         return ptrToRef(array.firstThat( f, args ));
  371.         }
  372.  
  373.     Object _FAR &lastThat( condFuncType f, void _FAR *args ) const
  374.         {
  375.         return ptrToRef(array.lastThat( f, args ));
  376.         }
  377.  
  378.     int getItemsInContainer() const
  379.         {
  380.         return array.getItemsInContainer();
  381.         }
  382.  
  383.     virtual classType isA() const
  384.         {
  385.         return arrayClass;
  386.         }
  387.  
  388.     virtual _TCHAR _FAR *nameOf() const
  389.         {
  390.         return "BI_TCArrayAsVector";
  391.         }
  392.  
  393.     int ownsElements()
  394.         {
  395.         return array.ownsElements();
  396.         }
  397.  
  398.     void ownsElements( int del )
  399.         {
  400.         array.ownsElements( del );
  401.         }
  402.  
  403.     ContainerIterator _FAR &initIterator() const;
  404.  
  405. private:
  406.  
  407.     BI_OArrayAsVector array;
  408.  
  409. };
  410.  
  411. class _CLASSTYPE BI_TCArrayAsVectorIterator : public ContainerIterator
  412. {
  413.  
  414. public:
  415.  
  416.     BI_TCArrayAsVectorIterator( const BI_TCArrayAsVector _FAR &a ) :
  417.         iter(a.array)
  418.         {
  419.         }
  420.  
  421.     virtual operator int()
  422.         {
  423.         return int(iter);
  424.         }
  425.  
  426.     virtual Object _FAR & current()
  427.         {
  428.         return Object::ptrToRef(iter.current());
  429.         }
  430.  
  431.     virtual Object _FAR & operator ++ ( int )
  432.         {
  433.         return Object::ptrToRef(iter++);
  434.         }
  435.  
  436.     virtual Object _FAR & operator ++ ()
  437.         {
  438.         return Object::ptrToRef(++iter);
  439.         }
  440.  
  441.     virtual void restart()
  442.         {
  443.         iter.restart();
  444.         }
  445.  
  446. private:
  447.  
  448.     BI_OArrayAsVectorIterator iter;
  449.  
  450. };
  451.  
  452. inline ContainerIterator _FAR & BI_TCArrayAsVector::initIterator() const
  453.         { return *new BI_TCArrayAsVectorIterator( *this ); }
  454.  
  455. /*------------------------------------------------------------------------*/
  456. /*                                                                        */
  457. /*  class BI_OSArrayAsVector                                              */
  458. /*                                                                        */
  459. /*  Implements a sorted array of pointers to Object,                      */
  460. /*  using a vector as the underlying implementation.                      */
  461. /*                                                                        */
  462. /*  Although the interface is written to take pointers to Object, in      */
  463. /*  fact, pointers to Sortable are required.                              */
  464. /*                                                                        */
  465. /*------------------------------------------------------------------------*/
  466.  
  467. class _CLASSTYPE BI_OSArrayAsVector
  468. {
  469.  
  470. public:
  471.  
  472.     friend class _CLASSTYPE BI_OSArrayAsVectorIterator;
  473.  
  474.     BI_OSArrayAsVector() : oarray( DEFAULT_ARRAY_SIZE, 0, 0 )
  475.         {
  476.         }
  477.  
  478.     BI_OSArrayAsVector( int upr, int lwr = 0, unsigned delta = 0 ) :
  479.         oarray( upr, lwr, delta )
  480.         {
  481.         }
  482.  
  483.     Object *operator [] (int loc)
  484.         {
  485.         return oarray[loc];
  486.         }
  487.  
  488.     Object *operator [] (int loc) const
  489.         {
  490.         return oarray[loc];
  491.         }
  492.  
  493.     int lowerBound() const
  494.         {
  495.         return oarray.lowerBound();
  496.         }
  497.  
  498.     int upperBound() const
  499.         {
  500.         return oarray.upperBound();
  501.         }
  502.  
  503.     sizeType arraySize() const
  504.         {
  505.         return oarray.arraySize();
  506.         }
  507.  
  508.     void add( Object _FAR *o )
  509.         {
  510.         PRECONDITION( o->isSortable() );
  511.         oarray.add(o);
  512.         }
  513.  
  514.     void detach( int loc,
  515.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  516.                )
  517.         {
  518.         oarray.detach( loc, dt );
  519.         }
  520.  
  521.     void detach( Object _FAR *o,
  522.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  523.                )
  524.         {
  525.         PRECONDITION( o->isSortable() );
  526.         oarray.detach( o, dt );
  527.         }
  528.  
  529.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  530.         {
  531.         oarray.flush( dt );
  532.         }
  533.  
  534.     int hasMember( Object _FAR *o ) const
  535.         {
  536.         PRECONDITION( o->isSortable() );
  537.         return oarray.hasMember(o);
  538.         }
  539.  
  540.     Object _FAR *findMember( Object _FAR *o ) const
  541.         {
  542.         PRECONDITION( o->isSortable() );
  543.         int loc = oarray.find(o);
  544.         return loc != INT_MAX ? oarray[loc] : 0;
  545.         }
  546.  
  547.     int isEmpty() const
  548.         {
  549.         return oarray.isEmpty();
  550.         }
  551.  
  552.     int isFull() const
  553.         {
  554.         return oarray.isFull();
  555.         }
  556.  
  557.     void forEach( iterFuncType f, void _FAR*args )
  558.         {
  559.         oarray.forEach( f, args );
  560.         }
  561.  
  562.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  563.         {
  564.         return oarray.firstThat( f, args );
  565.         }
  566.  
  567.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  568.         {
  569.         return oarray.lastThat( f, args );
  570.         }
  571.  
  572.     int getItemsInContainer() const
  573.         {
  574.         return oarray.getItemsInContainer();
  575.         }
  576.  
  577.     int ownsElements()
  578.         {
  579.         return oarray.ownsElements();
  580.         }
  581.  
  582.     void ownsElements( int del )
  583.         {
  584.         oarray.ownsElements( del );
  585.         }
  586.  
  587. protected:
  588.  
  589.     BI_ISArrayAsVector<Object> oarray;
  590.  
  591. };
  592.  
  593. class _CLASSTYPE BI_OSArrayAsVectorIterator :
  594.     public BI_ISArrayAsVectorIterator<Object>
  595. {
  596.  
  597. public:
  598.  
  599.     BI_OSArrayAsVectorIterator( const BI_OSArrayAsVector _FAR &a ) :
  600.         BI_ISArrayAsVectorIterator<Object>(a.oarray)
  601.         {
  602.         }
  603.  
  604. };
  605.  
  606. /*------------------------------------------------------------------------*/
  607. /*                                                                        */
  608. /*  class BI_TCSArrayAsVector                                             */
  609. /*                                                                        */
  610. /*  Implements a sorted Object array, with the full semantics of          */
  611. /*  the BC 2.0 style sorted array, using a vector as the underlying       */
  612. /*  implementation.                                                       */
  613. /*                                                                        */
  614. /*------------------------------------------------------------------------*/
  615.  
  616. class _CLASSTYPE BI_TCSArrayAsVector : public AbstractArray
  617. {
  618.  
  619. public:
  620.  
  621.     friend class _CLASSTYPE BI_TCSArrayAsVectorIterator;
  622.  
  623.     BI_TCSArrayAsVector( int upper = DEFAULT_ARRAY_SIZE,
  624.                          int lower = 0,
  625.                          sizeType delta = 0
  626.                        ) :
  627.         array( upper, lower, delta )
  628.         {
  629.         }
  630.  
  631.     virtual Object& operator []( int loc )
  632.         {
  633.         return ptrToRef(array[loc]);
  634.         }
  635.  
  636.     virtual Object& operator []( int loc ) const
  637.         {
  638.         return ptrToRef(array[loc]);
  639.         }
  640.  
  641.     virtual int lowerBound() const
  642.         {
  643.         return array.lowerBound();
  644.         }
  645.  
  646.     virtual int upperBound() const
  647.         {
  648.         return array.upperBound();
  649.         }
  650.  
  651.     virtual sizeType arraySize() const
  652.         {
  653.         return array.arraySize();
  654.         }
  655.  
  656.     void add( Object _FAR &o )
  657.         {
  658.         array.add(&o);
  659.         }
  660.  
  661.     virtual void detach( int loc, DeleteType dt = NoDelete )
  662.         {
  663.         array.detach( loc, dt );
  664.         }
  665.  
  666.     void detach( Object _FAR &o, DeleteType dt = NoDelete )
  667.         {
  668.         array.detach( &o, dt );
  669.         }
  670.  
  671.     void flush( TShouldDelete::DeleteType dt = DefDelete )
  672.         {
  673.         array.flush( dt );
  674.         }
  675.  
  676.     int hasMember( Object _FAR &o ) const
  677.         {
  678.         return array.hasMember(&o);
  679.         }
  680.  
  681.     Object _FAR &findMember( Object _FAR &o ) const
  682.         {
  683.         return ptrToRef(array.findMember(&o));
  684.         }
  685.  
  686.     int isEmpty() const
  687.         {
  688.         return array.isEmpty();
  689.         }
  690.  
  691.     int isFull() const
  692.         {
  693.         return array.isFull();
  694.         }
  695.  
  696.     void forEach( iterFuncType f, void _FAR*args )
  697.         {
  698.         array.forEach( f, args );
  699.         }
  700.  
  701.     Object _FAR &firstThat( condFuncType f, void _FAR *args ) const
  702.         {
  703.         return ptrToRef(array.firstThat( f, args ));
  704.         }
  705.  
  706.     Object _FAR &lastThat( condFuncType f, void _FAR *args ) const
  707.         {
  708.         return ptrToRef(array.lastThat( f, args ));
  709.         }
  710.  
  711.     int getItemsInContainer() const
  712.         {
  713.         return array.getItemsInContainer();
  714.         }
  715.  
  716.     virtual classType isA() const
  717.         {
  718.         return sortedArrayClass;
  719.         }
  720.  
  721.     virtual _TCHAR _FAR *nameOf() const
  722.         {
  723.         return "BI_TCSArrayAsVector";
  724.         }
  725.  
  726.     int ownsElements()
  727.         {
  728.         return array.ownsElements();
  729.         }
  730.  
  731.     void ownsElements( int del )
  732.         {
  733.         array.ownsElements( del );
  734.         }
  735.  
  736.     ContainerIterator _FAR & initIterator() const;
  737.  
  738. private:
  739.  
  740.     BI_OSArrayAsVector array;
  741.  
  742. };
  743.  
  744. class _CLASSTYPE BI_TCSArrayAsVectorIterator : public ContainerIterator
  745. {
  746.  
  747. public:
  748.  
  749.     BI_TCSArrayAsVectorIterator( const BI_TCSArrayAsVector _FAR &a ) :
  750.         iter(a.array)
  751.         {
  752.         }
  753.  
  754.     virtual operator int()
  755.         {
  756.         return int(iter);
  757.         }
  758.  
  759.     virtual Object _FAR & current()
  760.         {
  761.         return Object::ptrToRef(iter.current());
  762.         }
  763.  
  764.     virtual Object _FAR & operator ++ ( int )
  765.         {
  766.         return Object::ptrToRef(iter++);
  767.         }
  768.  
  769.     virtual Object _FAR & operator ++ ()
  770.         {
  771.         return Object::ptrToRef(++iter);
  772.         }
  773.  
  774.     virtual void restart()
  775.         {
  776.         iter.restart();
  777.         }
  778.  
  779. private:
  780.  
  781.     BI_OSArrayAsVectorIterator iter;
  782.  
  783. };
  784.  
  785. inline ContainerIterator _FAR & BI_TCSArrayAsVector::initIterator() const
  786.         {
  787.         return *new BI_TCSArrayAsVectorIterator( *this );
  788.         }
  789.  
  790. #endif  // TEMPLATES
  791.  
  792. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  793. #pragma option -po.
  794. #endif
  795. #pragma option -Vo.
  796.  
  797. #endif  // __ARRAY_H
  798.  
  799.